Kurs Next.js · Moduł 5: Strategie renderowania
Zaawansowane strategie cachowania w Next.js
W tej lekcji7
W poprzednim module poznaliśmy podstawy rewalidacji danych. Teraz czas zagłębić się w zaawansowane mechanizmy cachowania, które Next.js App Router oferuje pod maską. Zrozumienie tych warstw to klucz do tworzenia aplikacji, które działają błyskawicznie - niczym systemy w cyberpunkowym mieście Quantum, gdzie każda milisekunda opóźnienia może kosztować życie.
Architektura warstw cache w Next.js
Next.js App Router implementuje wielowarstwowy system cachowania. Każda warstwa ma inne zadanie i inny czas życia:
- Request Memoization - cache w pamięci na czas trwania jednego żądania serwerowego. Jeśli ten sam
fetchzostanie wywołany wielokrotnie w ramach jednego renderowania (np. w różnych komponentach), Next.js wykona go tylko raz. - Data Cache - trwały cache danych pobranych przez
fetch. Przetrwa między kolejnymi żądaniami użytkowników, a nawet między deploymentami. To właśnie ten cache kontrolujesz przezrevalidateicache: 'no-store'. - Full Route Cache - cache całych stron wygenerowanych statycznie (SSG/ISR). Przechowuje gotowy HTML i React Server Component Payload na serwerze.
- Router Cache - cache po stronie przeglądarki. Przechowuje odwiedzone strony i prefetchowane segmenty, żeby nawigacja kliencka była natychmiastowa.
Jak warstwy współpracują
Gdy użytkownik odwiedza stronę, Next.js sprawdza cache w następującej kolejności:
Router Cache (przeglądarka)
↓ miss
Full Route Cache (serwer)
↓ miss
Renderowanie strony → Request Memoization → Data Cache (gdy fetch włącza cache) → fetch do APIZrozumienie tego przepływu pozwala precyzyjnie kontrolować, które dane są świeże, a które mogą być serwowane z cache.
unstable_cache - cachowanie bez fetch
Nie wszystkie dane pochodzą z fetch. Gdy pobierasz dane z bazy danych (np. przez Prisma, Drizzle czy bezpośrednie zapytania), fetch nie jest zaangażowany i standardowy Data Cache nie działa. Do tego służy unstable_cache:
import { unstable_cache } from 'next/cache';
// Cachowanie zapytania do bazy danych
const getCachedUser = unstable_cache(
async (userId: string) => {
// To zapytanie zostanie zcachowane
const user = await db.user.findUnique({
where: { id: userId },
include: { posts: true, profile: true }
});
return user;
},
// Klucz cache - tablica stringów identyfikujących ten cache
['user-data'],
{
// Tagi do rewalidacji na żądanie
tags: ['users'],
// Czas rewalidacji w sekundach
revalidate: 3600
}
);
// Użycie w Server Component
export default async function UserProfile({ params }: { params: Promise<{ id: string }> }) {
const user = await getCachedUser((await params).id);
return (
<div>
<h1>{user.name}</h1>
<p>{user.profile?.bio}</p>
<h2>Posty ({user.posts.length})</h2>
</div>
);
}unstable_cache przyjmuje trzy argumenty:
- Funkcję asynchroniczną - operacja do zcachowania
- Klucz cache - tablica stringów tworzących unikalny identyfikator
- Opcje -
tags(do rewalidacji na żądanie) irevalidate(czas w sekundach)
Cache tags - precyzyjna kontrola rewalidacji
Tagi cache pozwalają grupować powiązane dane i rewalidować je razem. Jest to potężniejsze niż revalidatePath, bo działa niezależnie od ścieżek URL.
Strategia tagowania danych
// Dane produktu - oznaczone tagami ogólnym i specyficznym
async function getProduct(id: string) {
const res = await fetch(`https://api.example.com/products/${id}`, {
next: {
tags: [
'products', // tag ogólny - rewaliduje wszystkie produkty
`product-${id}` // tag specyficzny - rewaliduje tylko ten produkt
]
}
});
return res.json();
}
// Dane kategorii - powiązane z produktami
async function getCategory(slug: string) {
const res = await fetch(`https://api.example.com/categories/${slug}`, {
next: {
tags: [
'categories',
`category-${slug}`
]
}
});
return res.json();
}Rewalidacja na żądanie z tagami
// app/actions.ts
'use server';
import { revalidateTag, revalidatePath } from 'next/cache';
// Po aktualizacji jednego produktu
export async function updateProduct(id: string, data: ProductData) {
await db.product.update({ where: { id }, data });
// Rewaliduj tylko ten konkretny produkt
revalidateTag(`product-${id}`, 'max');
// Rewaliduj też listę produktów (np. stronę sklepu)
revalidateTag('products', 'max');
}
// Po masowej aktualizacji cen
export async function bulkUpdatePrices() {
await db.product.updateMany({ /* ... */ });
// Jedna komenda rewaliduje WSZYSTKIE produkty we wszystkich stronach
revalidateTag('products', 'max');
}revalidateTag vs revalidatePath - kiedy co użyć
| Metoda | Zasięg | Kiedy używać |
|---|---|---|
revalidateTag('products', 'max') | Wszystkie dane z tagiem 'products', niezależnie od strony | Gdy dane pojawiają się na wielu stronach |
revalidatePath('/products') | Cała strona /products - wszystkie dane na niej | Gdy chcesz odświeżyć konkretną stronę |
revalidatePath('/products', 'layout') | Strona + wszystkie podstrony z tym layoutem | Gdy zmienił się layout lub dane współdzielone |
Data Cache vs Full Route Cache vs Router Cache
Te trzy warstwy cache często są mylone. Oto kluczowe różnice:
Data Cache
Przechowuje wyniki fetch na serwerze. Kontrolujesz go przez:
// Dane cachowane na stałe (od Next.js 15 trzeba to włączyć jawnie)
fetch(url, { cache: 'force-cache' });
// Dane cachowane na 60 sekund
fetch(url, { next: { revalidate: 60 } });
// Dane nigdy nie cachowane
fetch(url, { cache: 'no-store' });Czas życia: Przetrwa między żądaniami i deploymentami (chyba że rewalidowany).
Full Route Cache
Przechowuje wygenerowany HTML + RSC Payload statycznych stron. Tworzony w czasie next build.
// Ta strona będzie w Full Route Cache (statyczna)
export default async function AboutPage() {
return <h1>O nas</h1>;
}
// Ta strona NIE będzie w Full Route Cache (dynamiczna)
export default async function DashboardPage() {
const session = await getSession(); // dynamic function
return <h1>Witaj, {session.user.name}</h1>;
}
// Wymuszenie rewalidacji Full Route Cache
export const revalidate = 3600; // strona rewalidowana co godzinęCzas życia: Do następnego next build lub rewalidacji.
Router Cache
Przechowuje odwiedzone strony w przeglądarce użytkownika. Dzięki niemu nawigacja wstecz jest natychmiastowa.
'use client';
import { useRouter } from 'next/navigation';
export function RefreshButton() {
const router = useRouter();
return (
<button onClick={() => {
// Wyczyść Router Cache i pobierz świeże dane z serwera
router.refresh();
}}>
Odśwież dane
</button>
);
}Czas życia:
- Strony statyczne: 5 minut
- Strony dynamiczne: 30 sekund
- Prefetched: do nawigacji
Cache scope - per-request vs cross-request
Ważne rozróżnienie, które wielu programistów pomija:
Per-request (Request Memoization)
Działa tylko w ramach jednego żądania serwerowego. Jeśli komponent A i komponent B wywołują ten sam fetch, zostanie on wykonany tylko raz:
// Oba komponenty współdzielą ten sam fetch w ramach jednego renderowania
async function Header() {
const user = await getUser(); // fetch #1
return <nav>{user.name}</nav>;
}
async function Sidebar() {
const user = await getUser(); // ten sam fetch - z memoizacji, nie z sieci!
return <aside>{user.avatar}</aside>;
}Cross-request (Data Cache)
Przetrwa między żądaniami różnych użytkowników:
async function getPopularPosts() {
// Te dane są współdzielone między WSZYSTKIMI użytkownikami
const res = await fetch('https://api.example.com/popular', {
next: { revalidate: 300 } // cache na 5 minut
});
return res.json();
}Debugowanie cache
Problemy z cache są jednymi z najtrudniejszych do zdiagnozowania. Oto sprawdzone techniki:
1. Logowanie w Server Components
export default async function Page() {
console.log('[Page] Rendering at:', new Date().toISOString());
const data = await getData();
console.log('[Page] Data fetched, first item:', data[0]?.id);
return <div>{/* ... */}</div>;
}Jeśli widzisz ten sam timestamp przy odświeżaniu - strona jest serwowana z Full Route Cache.
2. Nagłówek x-nextjs-cache
W trybie produkcyjnym Next.js dodaje nagłówek x-nextjs-cache do odpowiedzi:
HIT- strona z Full Route CacheMISS- strona renderowana na żywoSTALE- strona z cache, ale rewalidacja została wyzwolona w tle
3. Wymuszanie dynamicznego renderowania do testów
import { headers } from 'next/headers';
export default async function DebugPage() {
// Użycie await headers() wymusza dynamiczne renderowanie
const headersList = await headers();
return (
<div>
<p>Rendered: {new Date().toISOString()}</p>
<p>Ten timestamp powinien się zmieniać przy każdym odświeżeniu</p>
</div>
);
}Podsumowanie
Zaawansowane strategie cachowania w Next.js tworzą wielowarstwowy system, który - dobrze skonfigurowany - potrafi radykalnie przyspieszyć aplikację. Kluczowe wnioski:
- 4 warstwy cache - Request Memoization, Data Cache, Full Route Cache, Router Cache - każda z innym zasięgiem i czasem życia
unstable_cache- pozwala cachować dane z baz danych i innych źródeł nieopartych nafetch- Cache tags - precyzyjna kontrola rewalidacji:
revalidateTagdla danych,revalidatePathdla stron - Per-request vs cross-request - Request Memoization działa w ramach jednego renderowania, Data Cache między żądaniami
- Debugowanie - logowanie timestampów, nagłówki
x-nextjs-cache, wymuszanie dynamicznego renderowania
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Warstwy cache w Next.js App Router
// Request Memoization -> Data Cache -> Full Route Cache -> Router Cache
type CacheLayer = 'request-memo' | 'data-cache' | 'full-route' | 'router-cache';
interface LayerInfo {
id: CacheLayer;
name: string;
scope: string;
lifetime: string;
description: string;
invalidation: string;
example: string;
}
const layers: LayerInfo[] = [
{
id: 'request-memo',
name: 'Request Memoization',
scope: 'Per-request (serwer)',
lifetime: 'Czas trwania jednego renderowania',
description: 'Deduplikacja identycznych fetch w ramach jednego zadania. Jesli Header i Sidebar wolaja getUser(), fetch wykona sie raz.',
invalidation: 'Automatycznie po zakonczeniu renderowania',
example: 'const user = await getUser(); // wolany 3x, wykonany 1x',
},
{
id: 'data-cache',
name: 'Data Cache',
scope: 'Cross-request (serwer)',
lifetime: 'Miedzy zadaniami i deploymentami',
description: 'Trwaly cache wynikow fetch. Kontrolowany przez revalidate i cache options. Wspoldzielony miedzy uzytkownikami.',
invalidation: 'revalidateTag() / revalidatePath() / revalidate: N',
example: "fetch(url, { next: { revalidate: 60, tags: ['products'] } })",
},
{
id: 'full-route',
name: 'Full Route Cache',
scope: 'Statyczne strony (serwer)',
lifetime: 'Do nastepnego buildu lub rewalidacji',
description: 'Cache gotowego HTML + RSC Payload dla stron statycznych. Tworzony podczas next build.',
invalidation: 'revalidatePath() / next build / revalidate na stronie',
example: "export const revalidate = 3600; // cala strona co godzine",
},
{
id: 'router-cache',
name: 'Router Cache',
scope: 'Przegladarka uzytkownika',
lifetime: 'Statyczne: 5min, Dynamiczne: 30s',
description: 'Cache w przegladarce dla nawigacji klienckiej. Prefetchowane strony laduja natychmiast.',
invalidation: 'router.refresh() / automatycznie po czasie',
example: "router.refresh(); // wyczysc Router Cache",
},
];
export default function CacheLayersDemo() {
const [selected, setSelected] = useState<LayerInfo>(layers[0]);
const [requestFlow, setRequestFlow] = useState<{ layer: string; result: 'HIT' | 'MISS' }[]>([]);
const simulateRequest = () => {
const flow: { layer: string; result: 'HIT' | 'MISS' }[] = [];
let resolved = false;
for (const layer of layers) {
if (resolved) break;
const hit = Math.random() > 0.4;
flow.push({ layer: layer.name, result: hit ? 'HIT' : 'MISS' });
if (hit) resolved = true;
}
if (!resolved) {
flow.push({ layer: 'Origin API', result: 'MISS' });
}
setRequestFlow(flow);
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<h1 style={{ color: '#64ffda', fontSize: 18 }}>Warstwy cache w Next.js</h1>
<div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', margin: '16px 0' }}>
{layers.map((l, i) => (
<button key={l.id} onClick={() => setSelected(l)} style={{
background: selected.id === l.id ? '#1565c0' : '#1a2744',
color: '#fff', border: `1px solid ${selected.id === l.id ? '#64ffda' : '#333'}`,
borderRadius: 6, padding: '8px 12px', cursor: 'pointer', fontSize: 11, fontFamily: 'monospace'
}}>
{i + 1}. {l.name}
</button>
))}
</div>
<div style={{ background: '#0d1117', borderRadius: 8, padding: 16, marginBottom: 16 }}>
<div style={{ color: '#64ffda', fontSize: 15, marginBottom: 8 }}>{selected.name}</div>
<div style={{ display: 'grid', gap: 6, fontSize: 12 }}>
<div><span style={{ color: '#888' }}>Scope:</span> <span style={{ color: '#ce93d8' }}>{selected.scope}</span></div>
<div><span style={{ color: '#888' }}>Lifetime:</span> <span style={{ color: '#ffab40' }}>{selected.lifetime}</span></div>
<div><span style={{ color: '#888' }}>Opis:</span> {selected.description}</div>
<div><span style={{ color: '#888' }}>Inwalidacja:</span> <span style={{ color: '#ef5350' }}>{selected.invalidation}</span></div>
<code style={{ color: '#4caf50', background: '#1a2744', padding: '6px 10px', borderRadius: 4, fontSize: 11 }}>
{selected.example}
</code>
</div>
</div>
<button onClick={simulateRequest} style={{
background: '#4caf50', color: '#fff', border: 'none', borderRadius: 6,
padding: '8px 16px', cursor: 'pointer', fontFamily: 'monospace'
}}>
Symuluj request
</button>
{requestFlow.length > 0 && (
<div style={{ marginTop: 16 }}>
<div style={{ color: '#888', fontSize: 12, marginBottom: 8 }}>Przeplyw zadania przez warstwy cache:</div>
<div style={{ display: 'flex', gap: 4, alignItems: 'center', flexWrap: 'wrap' }}>
{requestFlow.map((step, i) => (
<React.Fragment key={i}>
{i > 0 && <span style={{ color: '#555' }}>-></span>}
<div style={{
background: step.result === 'HIT' ? '#1b5e20' : '#b71c1c',
borderRadius: 4, padding: '4px 8px', fontSize: 11
}}>
{step.layer}: {step.result}
</div>
</React.Fragment>
))}
</div>
</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. Do czego służy unstable_cache w Next.js App Router?
2. generateStaticParams służy do:
Zadania praktyczne w grze
- Edytor kodu
Utwórz stronę z optymalizacją: lazy loading, Suspense, proper caching, Image optimization
- Układanie w poziomie
Ułóż składnię eksportu dynamic w Next.js
- Klikanie w kolejności
Ułóż składnię komponentu Suspense z fallback w Next.js
- Edytor kodu
Utwórz Server Action do obsługi form submission z walidacją i database update
Zadania po tej lekcji
- PytanieFunkcja unstable_cache w Next.js
- PytaniegenerateStaticParams służy do:
- Zadanie z kodemPraktyka: Utwórz stronę z optymalizacją: lazy loading,
- Ułóż w kolejnościSkładnia eksportu dynamic w Next.js
- Kliknij w kolejnościSkładnia Suspense z fallback
- Zadanie z kodemPraktyka: Utwórz Server Action do obsługi form submission z