Kurs Next.js · Moduł 1: Konfiguracja Next.js
Renderowanie w Next.js - przegląd strategii
W tej lekcji8
W Metropolii Quantum informacje docierają do mieszkańców na różne sposoby - holograficzne ekrany na ulicach wyświetlają treści w czasie rzeczywistym, tablice informacyjne generują zawartość z wyprzedzeniem, a osobiste terminale pobierają dane na żądanie. Podobnie, Next.js oferuje kilka strategii renderowania stron, z których każda ma swoje zastosowanie.
W tym rozdziale poznasz cztery główne strategie renderowania w Next.js. Nie będziemy wchodzić w głębokie szczegóły techniczne - to temat na moduł 5. Na razie chcemy, żebyś rozumiał, że te strategie istnieją i wiedział, kiedy każda z nich ma sens.
Czym jest renderowanie?
Renderowanie to proces zamiany kodu React (JSX) na HTML, który przeglądarka może wyświetlić użytkownikowi. Kluczowe pytanie brzmi: gdzie i kiedy ten proces się odbywa?
// Ten komponent React...
export default function Hello() {
return <h1>Witaj w Metropolii Quantum!</h1>;
}
// ...zostaje zamieniony na HTML:
// <h1>Witaj w Metropolii Quantum!</h1>W zależności od wybranej strategii ta zamiana może nastąpić:
- Na serwerze - zanim strona dotrze do przeglądarki
- W przeglądarce - po pobraniu kodu JavaScript
- Podczas budowania - jeszcze przed uruchomieniem serwera
SSR - Server-Side Rendering (renderowanie po stronie serwera)
Wyobraź sobie, że w Metropolii Quantum holograficzny ekran generuje obraz w centrum sterowania i przesyła gotowy hologram do wyświetlenia. Użytkownik widzi kompletny obraz natychmiast po otwarciu transmisji.
SSR oznacza, że serwer renderuje stronę HTML przy każdym żądaniu użytkownika. Gdy ktoś wchodzi na stronę, serwer:
- Pobiera potrzebne dane (z bazy danych, API)
- Generuje kompletny HTML
- Wysyła gotową stronę do przeglądarki
// Server Component w Next.js - domyślnie renderowany na serwerze
export default async function DashboardPage() {
// Dane pobierane przy KAŻDYM żądaniu
const stats = await fetch('https://api.quantum.com/stats', { cache: 'no-store' });
const data = await stats.json();
return (
<div>
<h1>Panel Quantum</h1>
<p>Aktywni użytkownicy: {data.activeUsers}</p>
<p>Ostatnia aktualizacja: {data.timestamp}</p>
</div>
);
}Opcja cache: 'no-store' jest tu konieczna: bez niej (i bez API zależnych od żądania, takich jak cookies()) Next.js wyrenderuje stronę raz, podczas next build.
Kiedy używać SSR?
- Gdy dane zmieniają się często (np. panel użytkownika, koszyk zakupów)
- Gdy treść musi być aktualna przy każdym odświeżeniu
- Gdy potrzebujesz SEO dla dynamicznych treści
SSG - Static Site Generation (generowanie statycznych stron)
W Metropolii Quantum tablice informacyjne z rozkładem jazdy są drukowane raz dziennie i wywieszane na przystankach. Nie zmieniają się co sekundę - są przygotowane z wyprzedzeniem.
SSG oznacza, że strony HTML są generowane podczas budowania aplikacji (next build), a nie przy każdym żądaniu. Gotowe strony są serwowane natychmiast z CDN.
// Strona generowana statycznie podczas build
export default function AboutPage() {
return (
<div>
<h1>O Metropolii Quantum</h1>
<p>Założona w 2150 roku jako centrum technologii przyszłości.</p>
<p>Populacja: 12 milionów mieszkańców.</p>
</div>
);
}
// Ta strona nie wymaga danych dynamicznych
// Next.js wygeneruje ją raz podczas 'next build'Kiedy używać SSG?
- Blog, dokumentacja, strona "O nas"
- Treści, które rzadko się zmieniają
- Gdy priorytetem jest maksymalna szybkość ładowania
CSR - Client-Side Rendering (renderowanie po stronie klienta)
Osobiste terminale mieszkańców Metropolii Quantum pobierają surowe dane i renderują interfejs lokalnie - każdy terminal sam tworzy obraz na swoim ekranie.
CSR oznacza, że dane (a w klasycznej aplikacji SPA cały interfejs) są pobierane i renderowane w przeglądarce. W Next.js nawet komponent z "use client" jest przy pierwszym wejściu prerenderowany na serwerze do HTML, a potem hydratowany: w przykładzie niżej serwer wyśle nagłówek czatu, a wiadomości pobierze już przeglądarka.
"use client";
import { useState, useEffect } from 'react';
export default function LiveChat() {
const [messages, setMessages] = useState([]);
useEffect(() => {
// Dane pobierane w przeglądarce po załadowaniu komponentu
fetch('/api/messages')
.then(res => res.json())
.then(data => setMessages(data));
}, []);
return (
<div>
<h2>Quantum Chat</h2>
{messages.map(msg => (
<p key={msg.id}>{msg.text}</p>
))}
</div>
);
}Kiedy używać CSR?
- Interaktywne elementy (czat, formularze, dashboardy real-time)
- Gdy SEO nie jest potrzebne dla danej sekcji
- Gdy komponent wymaga dostępu do API przeglądarki (localStorage, geolokalizacja)
ISR - Incremental Static Regeneration (przyrostowa regeneracja statyczna)
W Metropolii Quantum tablice informacyjne mają tryb automatycznej aktualizacji - są statyczne, ale co określony czas (np. co godzinę) system sprawdza, czy nie ma nowych danych i generuje zaktualizowaną wersję.
ISR łączy zalety SSG (szybkość) z SSR (aktualność). Strona jest generowana statycznie, a gdy minie określony czas, pierwsze żądanie uruchamia w tle jej regenerację (samo dostaje jeszcze poprzednią wersję).
// Strona z ISR - statyczna, regenerowana w tle najwyżej raz na 60 sekund
export default async function ProductsPage() {
const res = await fetch('https://api.quantum.com/products', {
next: { revalidate: 60 } // Regeneracja w tle najwyżej raz na 60 sekund
});
const products = await res.json();
return (
<div>
<h1>Produkty Quantum Store</h1>
{products.map(p => (
<div key={p.id}>
<h3>{p.name}</h3>
<p>{p.price} kredytów</p>
</div>
))}
</div>
);
}Kiedy używać ISR?
- Sklep internetowy (produkty zmieniają się, ale nie co sekundę)
- Strona z artykułami/newsami
- Gdy chcesz szybkość SSG, ale z aktualizacjami
Prosty schemat decyzyjny - którą strategię wybrać?
Oto prosty schemat decyzyjny, który pomoże ci wybrać odpowiednią strategię:
Czy treść zmienia się przy każdym żądaniu?
TAK → Czy potrzebujesz SEO?
TAK → SSR (renderowanie na serwerze)
NIE → CSR (renderowanie w przeglądarce)
NIE → Czy treść zmienia się co jakiś czas?
TAK → ISR (statyczna z regeneracją)
NIE → SSG (w pełni statyczna)| Strategia | Szybkość | Aktualność danych | SEO | Przykład użycia |
|---|---|---|---|---|
| SSG | Najszybsza | Dane z momentu budowania | Tak | Blog, dokumentacja |
| ISR | Bardzo szybka | Odświeżane najwyżej co X sekund | Tak | Sklep, newsy |
| SSR | Szybka | Zawsze aktualne | Tak | Dashboard, profil |
| CSR | Zależy od klienta | Pobierane na żywo | Nie | Czat, formularze |
Co dalej?
W module 5 tego kursu zagłębimy się w szczegóły techniczne każdej strategii renderowania. Nauczysz się:
- Jak dokładnie konfigurować SSR i ISR w App Routerze
- Jak optymalizować wydajność renderowania
- Jak łączyć różne strategie w jednej aplikacji
- Zaawansowane wzorce z React Server Components
Na razie najważniejsze jest, żebyś zapamiętał, że Next.js daje ci wybór - nie musisz renderować wszystkiego w jeden sposób. Każda strona, a nawet każdy komponent, może używać innej strategii.
Podsumowanie
Metropolia Quantum pokazuje nam, że różne systemy dostarczania informacji mają różne zastosowania. Podobnie w Next.js:
- SSR - serwer renderuje stronę przy każdym żądaniu (dane zawsze aktualne)
- SSG - strona generowana raz podczas budowania (najszybsza)
- CSR - przeglądarka renderuje stronę po pobraniu JS (interaktywność)
- ISR - statyczna strona z automatyczną regeneracją (kompromis szybkości i aktualności)
Zrozumienie tych strategii to fundament pracy z Next.js. W kolejnych modułach będziesz je stosować w praktyce, budując coraz bardziej zaawansowane aplikacje w Metropolii Quantum.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Interaktywny przegląd strategii renderowania Next.js
const RenderingOverview = () => {
const [selected, setSelected] = useState<string | null>(null);
const strategies = [
{
id: 'ssr',
name: 'SSR',
fullName: 'Server-Side Rendering',
icon: '',
color: '#7c4dff',
speed: 'Szybka',
freshness: 'Zawsze aktualne',
seo: true,
description: 'Serwer renderuje stronę przy KAŻDYM żądaniu. Dane są zawsze świeże.',
useCase: 'Dashboard, profil użytkownika, koszyk zakupów',
code: 'export default async function Page() {\n const data = await fetch(url);\n return <div>{data.title}</div>;\n}',
},
{
id: 'ssg',
name: 'SSG',
fullName: 'Static Site Generation',
icon: '',
color: '#4caf50',
speed: 'Najszybsza',
freshness: 'Z momentu budowania',
seo: true,
description: 'Strony generowane RAZ podczas budowania. Serwowane z CDN.',
useCase: 'Blog, dokumentacja, strona O nas',
code: 'export default function About() {\n return <div>Statyczna treść</div>;\n}',
},
{
id: 'csr',
name: 'CSR',
fullName: 'Client-Side Rendering',
icon: '',
color: '#ff9800',
speed: 'Zależy od klienta',
freshness: 'Pobierane na żywo',
seo: false,
description: 'Przeglądarka pobiera JS i sama renderuje stronę.',
useCase: 'Czat, formularze, interaktywne dashboardy',
code: '"use client";\nimport { useState } from "react";\n// Renderowanie w przeglądarce',
},
{
id: 'isr',
name: 'ISR',
fullName: 'Incremental Static Regeneration',
icon: '',
color: '#e91e63',
speed: 'Bardzo szybka',
freshness: 'Co X sekund',
seo: true,
description: 'Statyczna strona z automatyczną regeneracją co określony czas.',
useCase: 'Sklep, artykuły, newsy',
code: 'const res = await fetch(url, {\n next: { revalidate: 60 }\n});',
},
];
const active = strategies.find(s => s.id === selected);
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#fff', fontFamily: 'sans-serif' }}>
<h1 style={{ color: '#64ffda', textAlign: 'center', marginBottom: '8px' }}>
Strategie Renderowania Next.js
</h1>
<p style={{ textAlign: 'center', color: '#888', marginBottom: '24px' }}>
Kliknij strategię, aby poznać szczegóły
</p>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: '12px', maxWidth: '800px', margin: '0 auto 24px' }}>
{strategies.map(s => (
<button key={s.id} onClick={() => setSelected(s.id)}
style={{ padding: '16px', background: selected === s.id ? s.color : 'rgba(255,255,255,0.05)',
border: selected === s.id ? 'none' : '1px solid #333', borderRadius: '10px',
color: '#fff', cursor: 'pointer', textAlign: 'center', transition: 'all 0.2s' }}>
<div style={{ fontSize: '2rem' }}>{s.icon}</div>
<div style={{ fontWeight: 'bold', marginTop: '4px' }}>{s.name}</div>
<div style={{ fontSize: '0.7rem', color: selected === s.id ? '#fff' : '#888' }}>{s.fullName}</div>
</button>
))}
</div>
{active && (
<div style={{ maxWidth: '800px', margin: '0 auto', background: 'rgba(255,255,255,0.05)',
borderRadius: '12px', padding: '24px', border: '1px solid ' + active.color }}>
<h2 style={{ color: active.color, marginBottom: '12px' }}>{active.icon} {active.fullName}</h2>
<p style={{ color: '#b0bec5', marginBottom: '16px' }}>{active.description}</p>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '12px', marginBottom: '16px' }}>
<div style={{ background: 'rgba(0,0,0,0.3)', padding: '12px', borderRadius: '8px', textAlign: 'center' }}>
<div style={{ color: '#888', fontSize: '0.8rem' }}>Szybkość</div>
<div style={{ color: '#64ffda', fontWeight: 'bold' }}>{active.speed}</div>
</div>
<div style={{ background: 'rgba(0,0,0,0.3)', padding: '12px', borderRadius: '8px', textAlign: 'center' }}>
<div style={{ color: '#888', fontSize: '0.8rem' }}>Aktualność</div>
<div style={{ color: '#64ffda', fontWeight: 'bold' }}>{active.freshness}</div>
</div>
<div style={{ background: 'rgba(0,0,0,0.3)', padding: '12px', borderRadius: '8px', textAlign: 'center' }}>
<div style={{ color: '#888', fontSize: '0.8rem' }}>SEO</div>
<div style={{ color: active.seo ? '#4caf50' : '#f44336', fontWeight: 'bold' }}>{active.seo ? 'Tak' : 'Nie'}</div>
</div>
</div>
<div style={{ background: '#0d1117', padding: '12px', borderRadius: '8px', marginBottom: '12px' }}>
<pre style={{ color: '#64ffda', margin: 0, fontSize: '13px', whiteSpace: 'pre-wrap' }}>{active.code}</pre>
</div>
<p style={{ color: '#888', fontSize: '0.9rem' }}>
<strong style={{ color: '#7c4dff' }}>Użyj gdy:</strong> {active.useCase}
</p>
</div>
)}
{!active && (
<div style={{ textAlign: 'center', color: '#555', paddingTop: '40px' }}>
Wybierz strategię renderowania powyżej
</div>
)}
</div>
);
};
export default RenderingOverview;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. Która strategia renderowania generuje strony HTML podczas budowania aplikacji (next build)?
2. Czym charakteryzuje się ISR (Incremental Static Regeneration) w Next.js?
3. Jak definiuje się zmienne środowiskowe dostępne po stronie klienta w Next.js?
4. Co oznacza dyrektywa 'use client' na początku pliku w Next.js?
5. Które narzędzie NIE jest częścią typowego środowiska deweloperskiego Next.js?
6. Który katalog w Next.js (App Router) zawiera definicje stron i ścieżek?
7. Która cecha Next.js automatycznie dzieli kod JavaScript na mniejsze paczki ładowane na żądanie?
Zadania praktyczne w grze
- Klikanie w kolejności
Ułóż prawidłową ścieżkę do pliku layoutu w App Routerze
- Układanie w pionie
Ułóż kolejność cyklu życia komponentów w App Routerze
- Układanie w pionie
Ułóż składnię użycia komponentu Image z Next.js
- Układanie w pionie
Ułóż kolejność pipeline'u optymalizacji obrazów w Next.js
- Klikanie w kolejności
Ułóż poprawną strukturę JSX z elementem div i nagłówkiem h1
- Układanie w pionie
Ułóż składnię funkcji getStaticProps w Pages Routerze (katalog pages/)
- Układanie w pionie
Ułóż kolejność obsługi żądania HTTP w Next.js
- Układanie w pionie
Ułóż składnię funkcji getServerSideProps w Pages Routerze (katalog pages/)
- Układanie w pionie
Ułóż kolejność przepływu żądania API przez proxy (dawniej middleware)
- Edytor kodu
Zbuduj w App Routerze stronę główną portfolio (plik app/page.jsx) jako domyślnie eksportowany komponent Portfolio. Wykonaj kolejno te kroki: 1. Główny element ma className="portfolio". 2. Na górze umieść <nav> z trzema linkami <Link> z next/link: „Start” (/), „Projekty” (/projects) i „Kontakt” (/contact). 3. Dodaj nagłówek <h1> ze swoim imieniem lub pseudonimem. 4. Utwórz tablicę projects z co najmniej 2 obiektami { id, title } i wyświetl ją w <ul> przez map: każdy projekt jako <li key={project.id}> z tytułem. 5. W styles.css dodaj regułę dla klasy .portfolio (np. tło i odstępy).
Zadania po tej lekcji
- PytanieStrategia SSG w Next.js
- PytanieZastosowanie ISR
- PytanieZmienne środowiskowe klienta w Next.js
- Kliknij w kolejnościŚcieżka pliku layout w App Routerze
- Ułóż w kolejnościCykl życia w App Routerze
- Ułóż w kolejnościUżycie komponentu Image
- PytanieDyrektywa 'use client' w Next.js
- Ułóż w kolejnościPipeline optymalizacji obrazów
- Kliknij w kolejnościStruktura JSX z div i h1
- Ułóż w kolejnościSkładnia getStaticProps
- PytanieŚrodowisko deweloperskie Next.js
- Ułóż w kolejnościObsługa żądania HTTP
- PytanieKatalog stron w App Routerze
- Ułóż w kolejnościSkładnia getServerSideProps
- Ułóż w kolejnościPrzepływ żądania API
- PytaniePaczki JavaScript ładowane na żądanie
- Zadanie z kodemPortfolio z App Routerem - krok po kroku
- Projekt do wysłaniaLink
- WideoVideo: Podsumowanie modułu