Kurs Next.js · Moduł 5: Strategie renderowania
Strategie renderowania w Next.js App Router
W tej lekcji9
Next.js zrewolucjonizował sposób tworzenia aplikacji React, oferując różne strategie renderowania, które można wybierać zależnie od charakterystyki strony i wymagań projektu. W tym module omówimy, jak strategie renderowania działają w kontekście App Router, wprowadzonego w Next.js 13 i rozwijanego w kolejnych wersjach.
Ewolucja renderowania w Next.js
Next.js przeszedł istotną ewolucję w podejściu do renderowania. W wersjach przed 13, używaliśmy specjalnych funkcji jak getStaticProps, getServerSideProps czy getStaticPaths, aby określić strategię renderowania dla danej strony. Każda strona musiała wybrać jedną konkretną strategię.
W App Router podejście jest inne - renderowanie jest teraz bardziej granularne i opiera się na koncepcji React Server Components. Zamiast określać strategię dla całej strony, możemy mieszać różne podejścia na poziomie poszczególnych komponentów.
React Server Components - fundament App Router
U podstaw nowego modelu renderowania leżą React Server Components (RSC), które zmieniły sposób myślenia o aplikacjach React. Główne cechy RSC to:
- Renderowanie na serwerze - komponenty są renderowane na serwerze, a do klienta trafia już gotowy HTML
- Brak wliczania do bundla JavaScript - kod RSC nie jest wysyłany do przeglądarki
- Bezpośredni dostęp do zasobów serwerowych - bazy danych, system plików itp.
- Brak dostępu do API przeglądarki - nie można używać hooks ani obsługiwać zdarzeń
Strategie renderowania w App Router
W App Router wciąż możemy korzystać z tradycyjnych strategii renderowania, ale sposób ich implementacji jest inny. Przyjrzyjmy się każdej z nich.
1. Renderowanie po stronie serwera (SSR - Server-Side Rendering)
W App Router, SSR jest domyślnym zachowaniem dla Route Handlers i Server Components.
// app/products/page.tsx
import { Product } from '@/components/Product';
async function getData() {
// Ta funkcja uruchamia się dla każdego żądania na serwerze
const res = await fetch('https://api.example.com/products', { cache: 'no-store' });
if (!res.ok) {
throw new Error('Failed to fetch data');
}
return res.json();
}
export default async function ProductsPage() {
const products = await getData();
return (
<div>
<h1>Nasze produkty</h1>
<div className="grid">
{products.map(product => (
<Product key={product.id} data={product} />
))}
</div>
</div>
);
}Kluczowe cechy SSR w App Router:
- Używamy opcji
cache: 'no-store'w funkcjifetchlubrevalidate: 0, aby wskazać, że dane powinny być pobierane przy każdym żądaniu - Komponenty są asynchroniczne (
async), co pozwala na bezpośrednie użycieawaitw ciele komponentu - Każde żądanie do strony powoduje ponowne renderowanie strony na serwerze
Zalety SSR:
- Zawsze aktualne dane
- Lepsza wydajność SEO (wyszukiwarki widzą pełną treść strony)
- Możliwość personalizacji treści dla każdego użytkownika
Wady SSR:
- Wolniejsze ładowanie strony (serwer musi przetworzyć każde żądanie)
- Większe obciążenie serwera
2. Generowanie statyczne (SSG - Static Site Generation)
W App Router, SSG osiągamy poprzez domyślne zachowanie fetch bez opcji cache: 'no-store'.
// app/blog/page.tsx
import { BlogPost } from '@/components/BlogPost';
async function getData() {
// Ta funkcja uruchamia się tylko w czasie budowania (lub na żądanie w trybie dev)
const res = await fetch('https://api.example.com/blog-posts');
if (!res.ok) {
throw new Error('Failed to fetch data');
}
return res.json();
}
export default async function BlogPage() {
const posts = await getData();
return (
<div>
<h1>Nasz blog</h1>
<div className="grid">
{posts.map(post => (
<BlogPost key={post.id} data={post} />
))}
</div>
</div>
);
}Kluczowe cechy SSG w App Router:
- Domyślnie wszystkie komponenty są renderowane statycznie, jeśli nie określono inaczej
- Dane są pobierane w czasie budowania aplikacji i "zamrażane" w statycznym HTML
- Nie ma potrzeby używania specjalnej funkcji jak
getStaticProps- wystarczy zwykłyfetch
Zalety SSG:
- Bardzo szybkie ładowanie stron (serwowane są statyczne pliki HTML)
- Minimalne obciążenie serwera
- Dobra wydajność SEO
Wady SSG:
- Dane mogą być nieaktualne (aktualizowane tylko przy przebudowie)
- Nie nadaje się do stron z treścią spersonalizowaną dla użytkownika
3. Przyrostowa regeneracja statyczna (ISR - Incremental Static Regeneration)
W App Router, ISR osiągamy poprzez dodanie opcji revalidate do funkcji fetch lub do segmentu trasy.
// app/products/[id]/page.tsx
import { ProductDetails } from '@/components/ProductDetails';
import { notFound } from 'next/navigation';
// Opcja 1: Rewalidacja na poziomie strony
export const revalidate = 3600; // Rewalidacja co godzinę
async function getProduct(id) {
// Opcja 2: Rewalidacja na poziomie funkcji fetch
const res = await fetch(`https://api.example.com/products/${id}`, {
next: { revalidate: 3600 } // Również co godzinę
});
if (!res.ok) {
return null;
}
return res.json();
}
export default async function ProductPage({ params }) {
const product = await getProduct((await params).id);
if (!product) {
notFound();
}
return <ProductDetails product={product} />;
}Kluczowe cechy ISR w App Router:
- Możemy określić czas rewalidacji na poziomie komponentu za pomocą eksportowanej zmiennej
revalidate - Możemy określić czas rewalidacji na poziomie żądania
fetchza pomocą opcjinext: { revalidate: seconds } - Istnieje możliwość wymuszenia rewalidacji za pomocą API Route Handler
Zalety ISR:
- Łączy zalety SSG (szybkość) i SSR (względna aktualność danych)
- Pozwala na aktualizację treści bez przebudowy całej aplikacji
- Dobre wsparcie dla SEO
Wady ISR:
- Dane nie są w 100% aktualne (istnieje opóźnienie zależne od ustawionego czasu rewalidacji)
- Złożoniejsza implementacja i debugowanie
4. Renderowanie po stronie klienta (CSR - Client-Side Rendering)
W App Router, CSR osiągamy poprzez oznaczenie komponentu jako "Client Component" przy użyciu dyrektywy 'use client' na początku pliku.
'use client';
// app/dashboard/page.tsx
import { useState, useEffect } from 'react';
export default function Dashboard() {
const [data, setData] = useState(null);
const [isLoading, setIsLoading] = useState(true);
useEffect(() => {
async function fetchData() {
try {
const res = await fetch('/api/dashboard-data');
const jsonData = await res.json();
setData(jsonData);
} catch (error) {
console.error('Error fetching data:', error);
} finally {
setIsLoading(false);
}
}
fetchData();
}, []);
if (isLoading) return <div>Ładowanie danych...</div>;
return (
<div>
<h1>Panel kontrolny</h1>
{/* Renderowanie danych pobranych po stronie klienta */}
{data && data.map(item => (
<div key={item.id}>{item.name}</div>
))}
</div>
);
}Kluczowe cechy CSR w App Router:
- Komponent musi być oznaczony dyrektywą
'use client' - Możemy używać hooków React (
useState,useEffectitp.) - Dane są pobierane po załadowaniu strony w przeglądarce
Zalety CSR:
- Może oferować lepsze doświadczenie użytkownika dla aplikacji interaktywnych
- Mniejsze obciążenie serwera (dane są pobierane bezpośrednio z API w przeglądarce)
- Dobra opcja dla treści spersonalizowanych dla zalogowanego użytkownika
Wady CSR:
- Słabsza wydajność SEO (wyszukiwarki mogą nie widzieć wszystkich treści)
- Wolniejsze początkowe ładowanie treści (użytkownik widzi stan ładowania)
- Większy rozmiar plików JavaScript przesyłanych do przeglądarki
Mieszane podejście - najlepsza praktyka w App Router
Jedną z największych zalet App Router jest możliwość mieszania różnych strategii renderowania w ramach jednej aplikacji, a nawet jednej strony. Dzięki temu możemy wybrać optymalną strategię dla każdego komponentu.
Przykład wykorzystania mieszanych strategii:
// app/products/[category]/page.tsx
import { ProductList } from '@/components/ProductList';
import { CategoryHeader } from '@/components/CategoryHeader';
import FilterSidebar from '@/components/FilterSidebar'; // Client Component
// Ta strona i jej dane są renderowane statycznie
// z rewalidacją co godzinę
export const revalidate = 3600;
// Określamy, które kategorie mają być generowane statycznie
export async function generateStaticParams() {
const categories = await fetch('https://api.example.com/categories').then(res => res.json());
return categories.map(category => ({
category: category.slug,
}));
}
async function getCategoryData(category) {
const categoryData = await fetch(`https://api.example.com/categories/${category}`);
return categoryData.json();
}
async function getProducts(category) {
const products = await fetch(`https://api.example.com/products?category=${category}`);
return products.json();
}
export default async function CategoryPage({ params }) {
// Pobieramy dane równolegle
const [categoryData, products] = await Promise.all([
getCategoryData((await params).category),
getProducts((await params).category),
]);
return (
<div className="grid grid-cols-4 gap-4">
{/* Statycznie renderowany nagłówek kategorii */}
<CategoryHeader data={categoryData} />
{/* Interaktywny filtr renderowany po stronie klienta */}
<div className="col-span-1">
<FilterSidebar initialProducts={products} />
</div>
{/* Statycznie renderowana lista produktów */}
<div className="col-span-3">
<ProductList products={products} />
</div>
</div>
);
}W tym przykładzie:
- Cała strona jest renderowana statycznie z rewalidacją co godzinę (ISR)
- Tylko określone kategorie są generowane w czasie budowania (
generateStaticParams) - Komponent
FilterSidebarjest Client Component, umożliwiający interaktywne filtrowanie po stronie klienta - Komponenty
CategoryHeaderiProductListsą Server Components renderowane statycznie
Kiedy używać której strategii?
Wybór strategii renderowania zależy od charakterystyki danej części aplikacji:
Strony statyczne (dokumentacja, landing page, strony informacyjne):
- Użyj SSG (domyślne zachowanie)
Treści dynamiczne, ale nie wymagające najnowszych danych (blog, katalog produktów):
- Użyj ISR z odpowiednim czasem rewalidacji
Treści wymagające najnowszych danych (ceny akcji, wiadomości, wyniki sportowe):
- Użyj SSR (
cache: 'no-store')
- Użyj SSR (
Treści spersonalizowane i interaktywne elementy interfejsu (panele kontrolne, formularze):
- Użyj CSR (
'use client')
- Użyj CSR (
Hybrydowe podejście (np. e-commerce):
- Statyczny szkielet strony (SSG/ISR)
- Dynamiczne dane produktów (SSR)
- Interaktywne elementy jak koszyk, filtry (CSR)
Dynamiczne i statyczne trasy
W App Router, możemy również określić, które ścieżki dynamiczne powinny być generowane statycznie podczas budowania aplikacji:
// app/blog/[slug]/page.tsx
export async function generateStaticParams() {
const posts = await fetch('https://api.example.com/posts').then(res => res.json());
return posts.map((post) => ({
slug: post.slug,
}));
}Dla tras, które nie są objęte przez generateStaticParams:
- Jeśli ustawiliśmy
dynamicParams = falsew opcjach segmentu, Next.js zwróci 404 - Jeśli
dynamicParams = true(domyślnie) lub nie jest ustawione, Next.js wygeneruje stronę na żądanie (SSR)
Optymalizacja stron dynamicznych
Jeśli mamy wiele dynamicznych podstron (np. tysiące produktów w e-commerce), możemy zoptymalizować proces budowania poprzez:
- Generowanie najpopularniejszych stron statycznie podczas budowania:
export async function generateStaticParams() {
// Pobierz tylko najpopularniejsze produkty
const popularProducts = await fetch('https://api.example.com/products/popular').then(res => res.json());
return popularProducts.map((product) => ({
id: product.id,
}));
}- On-demand Revalidation - rewalidacja poszczególnych stron na żądanie, np. po aktualizacji produktu:
// app/api/revalidate/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { revalidatePath } from 'next/cache';
export async function POST(request: NextRequest) {
const { path, secret } = await request.json();
// Sprawdzenie tajnego klucza dla bezpieczeństwa
if (secret !== process.env.REVALIDATION_SECRET) {
return NextResponse.json({ message: 'Invalid secret' }, { status: 401 });
}
if (!path) {
return NextResponse.json({ message: 'Path is required' }, { status: 400 });
}
try {
// Rewalidacja określonej ścieżki
revalidatePath(path);
return NextResponse.json({ revalidated: true, message: `Revalidated ${path}` });
} catch (err) {
return NextResponse.json({ message: 'Error revalidating' }, { status: 500 });
}
}Porównanie strategii renderowania
| Cecha | SSG | ISR | SSR | CSR |
|---|---|---|---|---|
| Wydajność | ||||
| SEO | ||||
| Aktualność danych | ||||
| Obciążenie serwera | ||||
| Interaktywność |
Podsumowanie
App Router w Next.js oferuje zaawansowane możliwości mieszania różnych strategii renderowania na poziomie komponentów, co pozwala na tworzenie wydajnych i elastycznych aplikacji. Kluczem do sukcesu jest wybór odpowiedniej strategii dla każdej części aplikacji, biorąc pod uwagę wymagania dotyczące wydajności, SEO i aktualności danych.
W następnym module omówimy bardziej szczegółowo mechanizmy rewalidacji danych w Next.js App Router, które są kluczowe dla implementacji ISR i zapewnienia aktualności treści.
Kod do tej lekcji: App.tsx
// Demo: Strategie renderowania w Next.js App Router
// SSG (Static), SSR (Dynamic), ISR (Incremental Static Regeneration)
import React, { useState } from 'react';
// Next.js App Router domyślnie używa Static Rendering (SSG)
// Dynamiczne renderowanie włącza się automatycznie gdy:
// - Użyjesz cookies(), headers(), searchParams
// - fetch() z { cache: 'no-store' }
// - export const dynamic = 'force-dynamic'
interface RenderingStrategy {
name: string;
shortName: string;
color: string;
when: string;
code: string;
pros: string[];
cons: string[];
buildTime: boolean;
requestTime: boolean;
}
const strategies: RenderingStrategy[] = [
{
name: 'Static Site Generation',
shortName: 'SSG',
color: '#7c4dff',
when: 'Build time (domyślnie w App Router)',
code: "// Domyślne zachowanie - nie trzeba nic dodawać\nexport default async function Page() {\n const data = await fetch(url); // cached\n return <div>{data}</div>;\n}",
pros: ['Najszybsze - HTML gotowy z CDN', 'Najtańsze - zero obliczeń per request', 'SEO-friendly'],
cons: ['Dane statyczne do następnego buildu', 'Nie nadaje się do personalizacji'],
buildTime: true,
requestTime: false,
},
{
name: 'Server-Side Rendering',
shortName: 'SSR',
color: '#64ffda',
when: 'Każde żądanie (on-demand)',
code: "// Wymuś dynamiczne renderowanie\nexport const dynamic = 'force-dynamic';\n// lub użyj cookies/headers\nimport { cookies } from 'next/headers';\n\nexport default async function Page() {\n const session = cookies().get('token');\n const data = await fetch(url, {\n cache: 'no-store'\n });\n return <div>{data}</div>;\n}",
pros: ['Zawsze aktualne dane', 'Personalizacja per-user', 'SEO-friendly'],
cons: ['Wolniejsze - serwer przetwarza każdy request', 'Wyższe koszty serwera'],
buildTime: false,
requestTime: true,
},
{
name: 'Incremental Static Regeneration',
shortName: 'ISR',
color: '#ff9800',
when: 'Build + odświeżanie co N sekund',
code: "// Rewalidacja co 60 sekund\nexport const revalidate = 60;\n\nexport default async function Page() {\n const data = await fetch(url, {\n next: { revalidate: 60 }\n });\n return <div>{data}</div>;\n}\n\n// Lub on-demand:\nimport { revalidatePath } from 'next/cache';\nrevalidatePath('/products');",
pros: ['Balans: szybkość SSG + aktualność SSR', 'Niskie koszty', 'Skalowalne'],
cons: ['Dane mogą być nieaktualne przez N sekund', 'Bardziej złożona konfiguracja'],
buildTime: true,
requestTime: true,
},
];
function StrategyCard({ strategy, isActive, onClick }: {
strategy: RenderingStrategy; isActive: boolean; onClick: () => void;
}) {
return (
<div onClick={onClick} style={{
background: isActive ? `${strategy.color}12` : 'rgba(255,255,255,0.02)',
border: `2px solid ${isActive ? strategy.color : 'rgba(255,255,255,0.08)'}`,
borderRadius: '12px', padding: '20px', cursor: 'pointer',
transition: 'all 0.3s ease',
}}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '8px' }}>
<h3 style={{ color: strategy.color, margin: 0 }}>{strategy.shortName}</h3>
<div style={{ display: 'flex', gap: '6px' }}>
{strategy.buildTime && (
<span style={{ background: '#7c4dff20', color: '#7c4dff', padding: '2px 8px', borderRadius: '10px', fontSize: '0.7rem' }}>
Build
</span>
)}
{strategy.requestTime && (
<span style={{ background: '#64ffda20', color: '#64ffda', padding: '2px 8px', borderRadius: '10px', fontSize: '0.7rem' }}>
Request
</span>
)}
</div>
</div>
<p style={{ color: '#b0bec5', fontSize: '0.85rem', margin: '0 0 8px' }}>{strategy.name}</p>
<p style={{ color: '#78909c', fontSize: '0.8rem', margin: 0 }}>{strategy.when}</p>
</div>
);
}
export default function RenderingStrategies() {
const [active, setActive] = useState(0);
const s = strategies[active];
return (
<div style={{
background: '#0f0f23', minHeight: '100vh', padding: '24px',
color: '#fff', fontFamily: 'system-ui, sans-serif',
}}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Strategie Renderowania</h1>
<p style={{ color: '#b0bec5', marginBottom: '24px' }}>
Next.js App Router - SSG vs SSR vs ISR
</p>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '12px', marginBottom: '24px' }}>
{strategies.map((st, i) => (
<StrategyCard key={st.shortName} strategy={st} isActive={i === active} onClick={() => setActive(i)} />
))}
</div>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '16px' }}>
<div style={{
background: 'rgba(0,0,0,0.3)', borderRadius: '12px', padding: '20px',
}}>
<h4 style={{ color: s.color, marginBottom: '12px' }}>Kod</h4>
<pre style={{ margin: 0, color: '#b0bec5', fontSize: '0.8rem', lineHeight: 1.6, whiteSpace: 'pre-wrap' }}>
{s.code}
</pre>
</div>
<div style={{ display: 'grid', gap: '16px' }}>
<div style={{ background: 'rgba(76,175,80,0.08)', borderRadius: '12px', padding: '16px' }}>
<h4 style={{ color: '#4caf50', marginBottom: '8px' }}>Zalety</h4>
{s.pros.map(p => (
<p key={p} style={{ color: '#b0bec5', fontSize: '0.85rem', margin: '4px 0' }}>+ {p}</p>
))}
</div>
<div style={{ background: 'rgba(244,67,54,0.08)', borderRadius: '12px', padding: '16px' }}>
<h4 style={{ color: '#f44336', marginBottom: '8px' }}>Wady</h4>
{s.cons.map(c => (
<p key={c} style={{ color: '#b0bec5', fontSize: '0.85rem', margin: '4px 0' }}>- {c}</p>
))}
</div>
</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. Co oznacza Server-Side Rendering (SSR) w kontekście Next.js?